#include "baseOp.h"
#include "command.h"
#include <stdexcept>

namespace SDHuaYi_Script
{

    BaseOP::BaseOP()
    {
    }

    /* 字符串转byte */
    QByteArray BaseOP::StrToHexByte(QString &hexString)
    {
        // 移除字符串中的空格
        hexString.replace(" ", "");

        // 确保字符串长度为偶数
        if (hexString.length() % 2 != 0)
        {
            hexString.prepend("0"); // 如果不是偶数，则在前面添加一个0
        }

        // 创建一个QByteArray来存储转换后的字节
        QByteArray byteArray;
        byteArray.resize(hexString.length() / 2); // 设置大小

        // 遍历字符串，每两个字符转换为一个字节
        for (int i = 0; i < hexString.length(); i += 2)
        {
            // 提取两个字符并转换为字节
            bool ok;
            byteArray[i / 2] = hexString.mid(i, 2).toLatin1().toInt(&ok, 16);
            if (!ok)
            {
                qWarning() << "Invalid hexadecimal character sequence at position" << i;
            }
        }

        return byteArray;
    }

    /* 带有字母的字符串转换为16进制字符串 */
    QString BaseOP::StrTohexStr(QString &strStrs)
    {
        QString hexOut;
        for (QChar letter : strStrs)
        {
            // 将字符转换为其整数值，并格式化为十六进制字符串
            hexOut.append(QString::number(letter.unicode(), 16).toUpper());
        }
        return hexOut;
    }

    /* byte数组转十六进制 */
    QString BaseOP::ToHexString(const QByteArray &bytes, int length)
    {
        try
        {
            QString hexString;
            if (!bytes.isEmpty())
            {
                for (int i = 0; i < length; ++i)
                {
                    // 将字节转换为两位的十六进制数，不足两位前面补0
                    hexString.append(QString("%1").arg(bytes.at(i), 2, 16, QChar('0')).toUpper());
                }
            }
            return hexString;
        }
        catch (...)
        {
            throw std::runtime_error("byte转十六进制字符串错误");
        }
    }

    int BaseOP::ParaUpdate(QList<Para> &para, Para &var1)
    {
        command cmd = command();
        int ret = 0;
        bool isExist = false;

        /* 检查是否需要进行隐形转换 */
        if (var1.Name.toUpper().startsWith("S") && var1.Value.trimmed().startsWith("#"))
        {
            /* 整形转换为16进制字符串类型 */
            var1.Value = cmd.ITOA_Process(var1.Value);
        }

        for (int i = 0; i < para.count(); i++)
        {
            /* 存在相同name的para对象则更新value值并退出 */
            if (para[i].Name == var1.Name)
            {
                para[i].Value = var1.Value;
                isExist = true;
                return ret;
            }
        }
        if (!isExist)
        {
            para.append(var1);
        }

        return ret;
    }

    int BaseOP::ParaInsert(QList<Para>& para, Para var1)
    {
        command cmd = command();
        int ret = 0;
        bool isExist = false;

        /* 检查是否需要进行隐形转换 */
        if (var1.Name.toUpper().startsWith("S") && var1.Value.trimmed().startsWith("#"))
        {
            /* 整形转换为16进制字符串类型 */
            var1.Value = cmd.ITOA_Process(var1.Value);
        }

        for (int i = 0; i < para.count(); i++)
        {
            /* 存在相同name的para对象则更新value值并退出 */
            if (para[i].Name == var1.Name)
            {
                // para[i].Value = var1.Value;
                isExist = true;
                return ret;
            }
        }
        if (!isExist)
        {
            para.append(var1);
        }

        return ret;
    }

    /* qlist元素值查询 */
    QString BaseOP::ParaQuery(QList<Para> &paras, QString &sDataIn)
    {
        // 遍历paras列表
        for (const auto &para : paras)
        {
            // 如果找到匹配的Name（不区分大小写），则返回对应的Value
            if (para.Name.toUpper() == sDataIn.toUpper())
            {
                return para.Value;
            }
        }
        // 如果没有找到匹配的Name，则返回原始的sDataIn
        return sDataIn;
    }

    /* byte转int */
    int BaseOP::Hex2Int(QByteArray hex)
    {
        int ret = 0;
        for (int i = 0; i < hex.length(); i++)
        {
            ret = (ret << 8) + hex[i];
        }
        return ret;
    }

    /* 单字节16进制字符串转int */
    qint16 BaseOP::HexToInt16(QString &p_strRam)
    {

        bool ok;
        qint16 a = p_strRam.toInt(&ok, 16); // 将QString作为十六进制数解析为qint16
        if (!ok)
        {
            throw std::runtime_error("HexToInt16 err");
        }

        return a;
    }

    /* 获取最终空间 */
    QString BaseOP::GetNewROOM(QString sPatchStaD, QString sROOM, QString sMFStaD)
    {
        QString sROOMEnd = sROOM;
        qint16 iPatchSta = HexToInt16(sPatchStaD);
        qint16 iMFAddress = HexToInt16(sMFStaD);
        qint16 iROOM = HexToInt16(sROOM);
        qint16 iRes = iPatchSta - iMFAddress;
        if (iRes < iROOM)
        {
            sROOMEnd = QString::number(iRes, 16).toUpper().leftJustified(4, '0');
        }
        return sROOMEnd;
    }

}
